package rabbitmq

import (
	"common/cron"
	"common/model"
	"common/pkg"
	"encoding/json"
	"fmt"
	"log"
	"order_server/dao/dao_redis"
	"strconv"
	"time"
)

// OrderData 在 OrderData 结构体中添加购物车商品支持
type OrderData struct {
	UserId        int64   `json:"userId"`
	ProductId     int64   `json:"productId"`
	Price         float64 `json:"price"`
	Num           int64   `json:"num"`
	Name          string  `json:"name"`
	OrderType     int64   `json:"orderType"`
	ActivityId    int64   `json:"activityId"`
	SeckillPrice  float64 `json:"seckillPrice"`
	OriginalPrice float64 `json:"originalPrice"`
	// 新增购物车支持字段
	CartItems    []CartItem `json:"cartItems,omitempty"`    // 购物车商品列表
	ProductNames []string   `json:"productNames,omitempty"` // 商品名称列表
}

type CartItem struct {
	ProductId int64   `json:"productId"`
	Price     float64 `json:"price"`
	Num       int64   `json:"num"`
	Name      string  `json:"name"`
}

// 在订单创建成功后添加购物车商品删除逻辑
func SimPleRecieve() (int64, string) {
	var (
		orderData OrderData
		url       string
		OrderId   int64
		OrderSn   string
	)

	log.Println("开始监听消息队列...")
	mq := NewRabbitMQSimple("kuteng")
	if mq == nil {
		log.Println("创建RabbitMQ实例失败")
		return 0, ""
	}
	defer mq.Destory()

	mq.ConsumeSimple(func(bytes []byte) {
		// 记录接收到的消息
		log.Printf("收到原始消息: %s", string(bytes))

		err := json.Unmarshal(bytes, &orderData)
		if err != nil {
			log.Printf("解析订单数据失败: %v, 原始数据: %s", err, string(bytes))
			return
		}

		log.Printf("解析后的订单数据: %+v", orderData)

		// 生成订单号
		orderNo := ""
		if orderData.OrderType == 2 {
			orderNo = "SK" + time.Now().Format("20060102150405") + strconv.FormatInt(orderData.UserId, 10)
			log.Printf("创建秒杀订单号: %s", orderNo)
		} else {
			t := time.Now()
			orderNo = t.Format("20060102150405") + strconv.FormatInt(orderData.UserId, 10)
			log.Printf("创建普通订单号: %s", orderNo)
		}

		//下单
		orderMaster := &model.OrderMaster{
			OrderNo: orderNo,
			UserId:  orderData.UserId,
			ProductId: func() int64 {
				// 根据订单类型设置商品ID
				if orderData.OrderType == 2 {
					// 秒杀订单：使用传入的商品ID
					return orderData.ProductId
				} else if len(orderData.CartItems) > 0 {
					// 购物车订单：使用第一个商品ID或设为0表示购物车订单
					return orderData.CartItems[0].ProductId
				}
				return 0
			}(),
			OrderType:     orderData.OrderType,
			OriginalPrice: orderData.OriginalPrice,
			ActualPrice: func() float64 {
				if orderData.OrderType == 2 {
					return orderData.SeckillPrice
				}
				return orderData.Price
			}(),
			Quantity:  orderData.Num,
			Status:    3, // 初始状态：待支付
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}

		log.Printf("准备创建订单，订单数据: %+v", orderMaster)

		// 创建主订单
		orderCrete, err := model.OrderCrete(orderMaster)
		if err != nil {
			log.Printf("创建主订单失败: %v", err)
			return
		}
		log.Printf("主订单创建成功，订单ID: %d", orderCrete.Id)

		// 新增：下单时扣减库存
		if orderData.ProductId != 0 {
			// 单商品订单：扣减指定商品库存
			err := model.ProductStockDel(orderData.ProductId, orderData.Num)
			if err != nil {
				log.Printf("库存扣减失败，商品ID: %d, 数量: %d, 错误: %v", orderData.ProductId, orderData.Num, err)
				return
			}
			log.Printf("成功扣减库存，商品ID: %d, 数量: %d", orderData.ProductId, orderData.Num)
		} else {
			// 购物车订单：批量扣减多个商品库存
			for _, item := range orderData.CartItems {
				err := model.ProductStockDel(item.ProductId, item.Num)
				if err != nil {
					log.Printf("购物车商品库存扣减失败，商品ID: %d, 数量: %d, 错误: %v", item.ProductId, item.Num, err)
					// 库存扣减失败，需要回滚已扣减的库存
					// 这里可以实现回滚逻辑
					return
				}
				log.Printf("成功扣减购物车商品库存，商品ID: %d, 数量: %d", item.ProductId, item.Num)
			}
		}

		// 下单时删除购物车商品
		if orderData.ProductId == 0 {
			// 购物车结算：删除已结算的商品
			if len(orderData.CartItems) > 0 {
				// 删除指定的购物车商品
				for _, item := range orderData.CartItems {
					err := dao_redis.CarProductDel(orderData.UserId, item.ProductId)
					if err != nil {
						log.Printf("删除购物车商品失败，商品ID: %d, 错误: %v", item.ProductId, err)
					} else {
						log.Printf("成功删除购物车商品，商品ID: %d", item.ProductId)
					}
				}
			} else {
				// 如果没有具体商品列表，清空整个购物车
				err := dao_redis.CarDel(orderData.UserId)
				if err != nil {
					log.Printf("清空购物车失败，用户ID: %d, 错误: %v", orderData.UserId, err)
				} else {
					log.Printf("成功清空购物车，用户ID: %d", orderData.UserId)
				}
			}
		} else {
			// 单商品购买：删除对应的购物车商品（如果存在）
			err := dao_redis.CarProductDel(orderData.UserId, orderData.ProductId)
			if err != nil {
				log.Printf("删除购物车商品失败（单商品），商品ID: %d, 错误: %v", orderData.ProductId, err)
			} else {
				log.Printf("成功删除购物车商品（单商品），商品ID: %d", orderData.ProductId)
			}
		}

		// 如果是秒杀订单，创建秒杀订单扩展记录
		if orderData.OrderType == 2 {
			log.Printf("检测到秒杀订单，准备创建秒杀订单扩展记录")
			seckillOrder := &model.OrderSeckill{
				OrderId:       orderCrete.Id,
				ActivityId:    orderData.ActivityId,
				SeckillPrice:  float32(orderData.SeckillPrice),
				OriginalPrice: float32(orderData.OriginalPrice),
				Status:        3, // 初始状态：待支付
				CreatedAt:     time.Now(),
				UpdatedAt:     time.Now(),
			}

			err = model.SeckillOrderCreate(seckillOrder)
			if err != nil {
				log.Printf("创建秒杀订单失败: %v", err)
				// 如果创建秒杀订单失败，删除主订单
				model.OrderMasterDelete(orderMaster)
				return
			}
			log.Printf("秒杀订单扩展记录创建成功")
		}

		// 创建支付链接
		pay := pkg.NewPay()
		if pay == nil {
			log.Println("创建支付实例失败")
			return
		}

		orderPrice := strconv.FormatFloat(orderCrete.ActualPrice, 'f', -1, 64)
		var payErr error

		//判断订单类型和来源
		switch {
		case orderData.OrderType == 2:
			// 秒杀订单
			url, payErr = pay.Pay("秒杀商品-"+orderData.Name, orderCrete.OrderNo, orderPrice)
			log.Printf("创建秒杀订单支付链接")
		case orderData.ProductId == 0:
			// 购物车结算
			url, payErr = pay.Pay("购物车结算", orderCrete.OrderNo, orderPrice)
			log.Printf("创建购物车订单支付链接")
		default:
			// 普通商品
			url, payErr = pay.Pay(orderData.Name, orderCrete.OrderNo, orderPrice)
			log.Printf("创建普通订单支付链接")
		}

		if payErr != nil {
			log.Printf("创建支付链接失败: %v", payErr)
			return
		}
		log.Printf("支付链接创建成功: %s", url)

		//获取订单id和订单号
		OrderId = orderCrete.Id
		OrderSn = orderCrete.OrderNo
		fmt.Println(OrderId, OrderSn)

		//设置定时任务
		cron.OrderUpdatePaidTime(OrderSn)
		log.Printf("订单处理完成，订单ID: %d, 订单号: %s", OrderId, OrderSn)
	})

	return OrderId, url
}
